home *** CD-ROM | disk | FTP | other *** search
/ InterCD 2000 September / september_2000.iso / intercd / root / ^Linux / cdrtools-1.10 / cdrecord / drv_mmc.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-07-30  |  36.4 KB  |  1,423 lines
  1. /* @(#)drv_mmc.c    1.57 00/07/30 Copyright 1997 J. Schilling */
  2. #ifndef lint
  3. static    char sccsid[] =
  4.     "@(#)drv_mmc.c    1.57 00/07/30 Copyright 1997 J. Schilling";
  5. #endif
  6. /*
  7.  *    CDR device implementation for
  8.  *    SCSI-3/mmc conforming drives
  9.  *    e.g. Yamaha CDR-400, Ricoh MP6200
  10.  *
  11.  *    Copyright (c) 1997 J. Schilling
  12.  */
  13. /*
  14.  * This program is free software; you can redistribute it and/or modify
  15.  * it under the terms of the GNU General Public License as published by
  16.  * the Free Software Foundation; either version 2, or (at your option)
  17.  * any later version.
  18.  *
  19.  * This program is distributed in the hope that it will be useful,
  20.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22.  * GNU General Public License for more details.
  23.  *
  24.  * You should have received a copy of the GNU General Public License
  25.  * along with this program; see the file COPYING.  If not, write to
  26.  * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  27.  */
  28.  
  29. /*#define    DEBUG*/
  30. #define    PRINT_ATIP
  31. #include <mconfig.h>
  32.  
  33. #include <stdio.h>
  34. #include <standard.h>
  35. #include <fctldefs.h>
  36. #include <errno.h>
  37. #include <strdefs.h>
  38. #include <stdxlib.h>
  39. #include <unixstd.h>
  40. #include <timedefs.h>
  41.  
  42. #include <utypes.h>
  43. #include <btorder.h>
  44. #include <intcvt.h>
  45. #include <schily.h>
  46.  
  47. #include <scg/scgcmd.h>
  48. #include <scg/scsidefs.h>
  49. #include <scg/scsireg.h>
  50. #include <scg/scsitransp.h>
  51.  
  52. #include <scsimmc.h>
  53. #include "cdrecord.h"
  54.  
  55. extern    BOOL    isgui;
  56. extern    char    *driveropts;
  57.  
  58. extern    int    debug;
  59. extern    int    lverbose;
  60.  
  61. LOCAL    int    curspeed = 1;
  62.  
  63. LOCAL    int    mmc_load        __PR((SCSI *scgp));
  64. LOCAL    int    mmc_unload        __PR((SCSI *scgp));
  65. LOCAL    void    mmc_opthelp        __PR((cdr_t *dp, int excode));
  66. LOCAL    cdr_t    *identify_mmc        __PR((SCSI *scgp, cdr_t *, struct scsi_inquiry *));
  67. LOCAL    int    attach_mmc        __PR((SCSI *scgp, cdr_t *));
  68. LOCAL    int    get_diskinfo        __PR((SCSI *scgp, struct disk_info *dip));
  69. LOCAL    void    di_to_dstat        __PR((struct disk_info *dip, dstat_t *dsp));
  70. #ifdef    PRINT_ATIP
  71. LOCAL    int    get_pma            __PR((SCSI *scgp));
  72. #endif
  73. LOCAL    int    getdisktype_mmc        __PR((SCSI *scgp, cdr_t *dp, dstat_t *dsp));
  74. LOCAL    int    speed_select_mmc    __PR((SCSI *scgp, int *speedp, int dummy));
  75. LOCAL    int    next_wr_addr_mmc    __PR((SCSI *scgp, int track, track_t *trackp, long *ap));
  76. LOCAL    int    open_track_mmc        __PR((SCSI *scgp, cdr_t *dp, int track, track_t *trackp));
  77. LOCAL    int    close_track_mmc        __PR((SCSI *scgp, int track, track_t *trackp));
  78. LOCAL    int    open_session_mmc    __PR((SCSI *scgp, cdr_t *dp, int tracks, track_t *trackp, int toctype, int multi));
  79. LOCAL    int    waitfix_mmc        __PR((SCSI *scgp, int secs));
  80. LOCAL    int    fixate_mmc        __PR((SCSI *scgp, int onp, int dummy, int toctype, int tracks, track_t *trackp));
  81. LOCAL    int    blank_mmc        __PR((SCSI *scgp, long addr, int blanktype));
  82. LOCAL    int    send_opc_mmc        __PR((SCSI *scgp, caddr_t, int cnt, int doopc));
  83. LOCAL    int    scsi_sony_write        __PR((SCSI *scgp, caddr_t bp, long sectaddr, long size, int blocks, BOOL islast));
  84.  
  85. LOCAL    int    send_cue    __PR((SCSI *scgp, int tracks, track_t *trackp));
  86.  
  87. LOCAL int
  88. mmc_load(scgp)
  89.     SCSI    *scgp;
  90. {
  91.     return (scsi_load_unload(scgp, 1));
  92. }
  93.  
  94. LOCAL int
  95. mmc_unload(scgp)
  96.     SCSI    *scgp;
  97. {
  98.     return (scsi_load_unload(scgp, 0));
  99. }
  100.  
  101. cdr_t    cdr_mmc = {
  102.     0,
  103.     CDR_TAO|CDR_DAO|CDR_PACKET|CDR_SWABAUDIO,
  104.     "mmc_cdr",
  105.     "generic SCSI-3/mmc CD-R driver",
  106.     0,
  107.     identify_mmc,
  108.     attach_mmc,
  109.     getdisktype_mmc,
  110.     scsi_load,
  111. /*    mmc_load,*/
  112.     scsi_unload,
  113.     read_buff_cap,
  114.     (int(*)__PR((SCSI *)))cmd_dummy,    /* recovery_needed    */
  115.     (int(*)__PR((SCSI *, int)))cmd_dummy,    /* recover        */
  116.     speed_select_mmc,
  117.     select_secsize,
  118.     next_wr_addr_mmc,
  119.     (int(*)__PR((SCSI *, Ulong)))cmd_ill,    /* reserve_track    */
  120.     scsi_cdr_write,
  121.     send_cue,
  122.     open_track_mmc,
  123.     close_track_mmc,
  124.     open_session_mmc,
  125.     cmd_dummy,
  126.     read_session_offset,
  127.     fixate_mmc,
  128.     blank_mmc,
  129.     send_opc_mmc,
  130. };
  131.  
  132. cdr_t    cdr_mmc_sony = {
  133.     0,
  134.     CDR_TAO|CDR_DAO|CDR_PACKET|CDR_SWABAUDIO,
  135.     "mmc_cdr_sony",
  136.     "generic SCSI-3/mmc CD-R driver (Sony 928 variant)",
  137.     0,
  138.     identify_mmc,
  139.     attach_mmc,
  140.     getdisktype_mmc,
  141.     scsi_load,
  142. /*    mmc_load,*/
  143.     scsi_unload,
  144.     read_buff_cap,
  145.     (int(*)__PR((SCSI *)))cmd_dummy,    /* recovery_needed    */
  146.     (int(*)__PR((SCSI *, int)))cmd_dummy,    /* recover        */
  147.     speed_select_mmc,
  148.     select_secsize,
  149.     next_wr_addr_mmc,
  150.     (int(*)__PR((SCSI *, Ulong)))cmd_ill,    /* reserve_track    */
  151.     scsi_sony_write,
  152.     send_cue,
  153.     open_track_mmc,
  154.     close_track_mmc,
  155.     open_session_mmc,
  156.     cmd_dummy,
  157.     read_session_offset,
  158.     fixate_mmc,
  159.     blank_mmc,
  160.     send_opc_mmc,
  161. };
  162.  
  163. /*
  164.  * SCSI-3/mmc conformant CD drive
  165.  */
  166. cdr_t    cdr_cd = {
  167.     0,
  168.     CDR_ISREADER|CDR_SWABAUDIO,
  169.     "mmc_cd",
  170.     "generic SCSI-3/mmc CD driver",
  171.     0,
  172.     identify_mmc,
  173.     attach_mmc,
  174.     drive_getdisktype,
  175.     scsi_load,
  176.     scsi_unload,
  177.     read_buff_cap,
  178.     (int(*)__PR((SCSI *)))cmd_dummy,    /* recovery_needed    */
  179.     (int(*)__PR((SCSI *, int)))cmd_dummy,    /* recover        */
  180.     speed_select_mmc,
  181.     select_secsize,
  182.     (int(*)__PR((SCSI *scgp, int, track_t *, long *)))cmd_ill,    /* next_wr_addr        */
  183.     (int(*)__PR((SCSI *, Ulong)))cmd_ill,    /* reserve_track    */
  184.     scsi_cdr_write,
  185.     no_sendcue,
  186.     open_track_mmc,
  187.     close_track_mmc,
  188.     (int(*)__PR((SCSI *scgp, cdr_t *, int, track_t *, int, int)))cmd_dummy,
  189.     cmd_dummy,
  190.     read_session_offset,
  191.     (int(*)__PR((SCSI *scgp, int, int, int, int, track_t *)))cmd_dummy,    /* fixation */
  192.     blank_dummy,
  193.     (int(*)__PR((SCSI *, caddr_t, int, int)))NULL,    /* no OPC    */
  194. };
  195.  
  196. /*
  197.  * Old pre SCSI-3/mmc CD drive
  198.  */
  199. cdr_t    cdr_oldcd = {
  200.     0,
  201.     CDR_ISREADER,
  202.     "scsi2_cd",
  203.     "generic SCSI-2 CD driver",
  204.     0,
  205.     identify_mmc,
  206.     drive_attach,
  207.     drive_getdisktype,
  208.     scsi_load,
  209.     scsi_unload,
  210.     buf_dummy,
  211.     (int(*)__PR((SCSI *)))cmd_dummy,    /* recovery_needed    */
  212.     (int(*)__PR((SCSI *, int)))cmd_dummy,    /* recover        */
  213.     speed_select_mmc,
  214.     select_secsize,
  215.     (int(*)__PR((SCSI *scg, int, track_t *, long *)))cmd_ill,    /* next_wr_addr        */
  216.     (int(*)__PR((SCSI *, Ulong)))cmd_ill,    /* reserve_track    */
  217.     scsi_cdr_write,
  218.     no_sendcue,
  219.     open_track_mmc,
  220.     close_track_mmc,
  221.     (int(*)__PR((SCSI *scgp, cdr_t *, int, track_t *, int, int)))cmd_dummy,
  222.     cmd_dummy,
  223.     read_session_offset_philips,
  224.     (int(*)__PR((SCSI *scgp, int, int, int, int, track_t *)))cmd_dummy,    /* fixation */
  225.     blank_dummy,
  226.     (int(*)__PR((SCSI *, caddr_t, int, int)))NULL,    /* no OPC    */
  227. };
  228.  
  229. LOCAL void
  230. mmc_opthelp(dp, excode)
  231.     cdr_t    *dp;
  232.     int    excode;
  233. {
  234.     error("Driver options:\n");
  235.     if (dp->cdr_cdcap->res_4 != 0) {
  236.         error("burnproof    Prepare writer to use Sanyo BURN-Proof technology\n");
  237.         error("noburnproof    Disable using Sanyo BURN-Proof technology\n");
  238.     } else {
  239.         error("None supported for this drive.\n");
  240.     }
  241.     exit(excode);
  242. }
  243.  
  244. LOCAL cdr_t *
  245. identify_mmc(scgp, dp, ip)
  246.     SCSI    *scgp;
  247.     cdr_t            *dp;
  248.     struct scsi_inquiry    *ip;
  249. {
  250.     BOOL    cdrr     = FALSE;    /* Read CD-R    */
  251.     BOOL    cdwr     = FALSE;    /* Write CD-R    */
  252.     BOOL    cdrrw     = FALSE;    /* Read CD-RW    */
  253.     BOOL    cdwrw     = FALSE;    /* Write CD-RW    */
  254.     Uchar    mode[0x100];
  255.     struct    cd_mode_page_2A *mp;
  256.  
  257.     if (ip->type != INQ_WORM && ip->type != INQ_ROMD)
  258.         return ((cdr_t *)0);
  259.  
  260.     allow_atapi(scgp, TRUE);/* Try to switch to 10 byte mode cmds */
  261.  
  262.     scgp->silent++;
  263.     mp = mmc_cap(scgp, mode);    /* Get MMC capabilities */
  264.     scgp->silent--;
  265.     if (mp == NULL)
  266.         return (&cdr_oldcd);    /* Pre SCSI-3/mmc drive         */
  267.  
  268.     mmc_getval(mp, &cdrr, &cdwr, &cdrrw, &cdwrw, NULL);
  269.  
  270.     /*
  271.      * At this point we know that we have a SCSI-3/mmc compliant drive.
  272.      * Unfortunately ATAPI drives violate the SCSI spec in returning
  273.      * a response data format of '1' which from the SCSI spec would
  274.      * tell us not to use the "PF" bit in mode select. As ATAPI drives
  275.      * require the "PF" bit to be set, we 'correct' the inquiry data.
  276.      *
  277.      * XXX xxx_identify() should not have any side_effects ??
  278.      */
  279.     if (ip->data_format < 2)
  280.         ip->data_format = 2;
  281.  
  282.     if (strncmp(ip->vendor_info, "SONY", 4) == 0 &&
  283.         strncmp(ip->prod_ident, "CD-R   CDU928E", 14) == 0) {
  284.         dp = &cdr_mmc_sony;
  285.     }
  286.     if (!cdwr)            /* SCSI-3/mmc CD drive        */
  287.         dp = &cdr_cd;
  288.  
  289.     return (dp);
  290. }
  291.  
  292. LOCAL int
  293. attach_mmc(scgp, dp)
  294.     SCSI    *scgp;
  295.     cdr_t            *dp;
  296. {
  297.     struct    cd_mode_page_2A *mp;
  298.  
  299.     allow_atapi(scgp, TRUE);/* Try to switch to 10 byte mode cmds */
  300.  
  301.     scgp->silent++;
  302.     mp = mmc_cap(scgp, NULL);/* Get MMC capabilities in allocated mp */
  303.     scgp->silent--;
  304.     if (mp == NULL)
  305.         return (-1);    /* Pre SCSI-3/mmc drive         */
  306.  
  307.     dp->cdr_cdcap = mp;    /* Store MMC cap pointer    */
  308.  
  309.     if (mp->loading_type == LT_TRAY)
  310.         dp->cdr_flags |= CDR_TRAYLOAD;
  311.     else if (mp->loading_type == LT_CADDY)
  312.         dp->cdr_flags |= CDR_CADDYLOAD;
  313.  
  314.     if (driveropts != NULL) {
  315.         if (strcmp(driveropts, "help") == 0) {
  316.             mmc_opthelp(dp, 0);
  317.         }
  318.     }
  319.  
  320.     return (0);
  321. }
  322.  
  323. #ifdef    PRINT_ATIP
  324. LOCAL    int    get_atip        __PR((SCSI *scgp, struct atipinfo *atp));
  325.     void    print_di        __PR((struct disk_info *dip));
  326.     void    print_atip        __PR((SCSI *scgp, struct atipinfo *atp));
  327. #endif    /* PRINT_ATIP */
  328.  
  329. LOCAL int
  330. get_diskinfo(scgp, dip)
  331.     SCSI        *scgp;
  332.     struct disk_info *dip;
  333. {
  334.     int    len;
  335.     int    ret;
  336.  
  337.     fillbytes((caddr_t)dip, sizeof(*dip), '\0');
  338.  
  339.     if (read_disk_info(scgp, (caddr_t)dip, 2) < 0)
  340.         return (-1);
  341.     len = a_to_u_2_byte(dip->data_len);
  342.     len += 2;
  343.     ret = read_disk_info(scgp, (caddr_t)dip, len);
  344.  
  345. #ifdef    DEBUG
  346.     scg_prbytes("Disk info:", (u_char *)dip,
  347.                 len-scg_getresid(scgp));
  348. #endif
  349.     return (ret);
  350. }
  351.  
  352. LOCAL void
  353. di_to_dstat(dip, dsp)
  354.     struct disk_info    *dip;
  355.     dstat_t    *dsp;
  356. {
  357.     dsp->ds_diskid = a_to_u_4_byte(dip->disk_id);
  358.     if (dip->did_v)
  359.         dsp->ds_flags |= DSF_DID_V;
  360.     dsp->ds_diskstat = dip->disk_status;
  361.     dsp->ds_sessstat = dip->sess_status;
  362.  
  363.     dsp->ds_maxblocks = msf_to_lba(dip->last_lead_out[1],
  364.                     dip->last_lead_out[2],
  365.                     dip->last_lead_out[3], TRUE);
  366.     /*
  367.      * Check for 0xFF:0xFF/0xFF which is an indicator for a complete disk
  368.      */
  369.     if (dsp->ds_maxblocks == 716730)
  370.         dsp->ds_maxblocks = -1L;
  371.  
  372.     if (dsp->ds_first_leadin == 0) {
  373.         dsp->ds_first_leadin = msf_to_lba(dip->last_lead_in[1],
  374.                         dip->last_lead_in[2],
  375.                         dip->last_lead_in[3], FALSE);
  376.         if (dsp->ds_first_leadin > 0)
  377.             dsp->ds_first_leadin = 0;
  378.     }
  379.  
  380.     if (dsp->ds_last_leadout == 0 && dsp->ds_maxblocks >= 0)
  381.         dsp->ds_last_leadout = dsp->ds_maxblocks;
  382. }
  383.  
  384. #ifdef    PRINT_ATIP
  385.  
  386. LOCAL int
  387. get_atip(scgp, atp)
  388.     SCSI        *scgp;
  389.     struct atipinfo *atp;
  390. {
  391.     int    len;
  392.     int    ret;
  393.  
  394.     fillbytes((caddr_t)atp, sizeof(*atp), '\0');
  395.  
  396.     if (read_toc(scgp, (caddr_t)atp, 0, 2, 0, FMT_ATIP) < 0)
  397.         return (-1);
  398.     len = a_to_u_2_byte(atp->hd.len);
  399.     len += 2;
  400.     ret = read_toc(scgp, (caddr_t)atp, 0, len, 0, FMT_ATIP);
  401.  
  402. #ifdef    DEBUG
  403.     scg_prbytes("ATIP info:", (u_char *)atp,
  404.                 len-scg_getresid(scgp));
  405. #endif
  406.     /*
  407.      * Yamaha sometimes returns zeroed ATIP info for disks without ATIP
  408.      */
  409.     if (atp->desc.lead_in[1] == 0 &&
  410.             atp->desc.lead_in[2] == 0 &&
  411.             atp->desc.lead_in[3] == 0 &&
  412.             atp->desc.lead_out[1] == 0 &&
  413.             atp->desc.lead_out[2] == 0 &&
  414.             atp->desc.lead_out[3] == 0)
  415.         return (-1);
  416.  
  417.     if (atp->desc.lead_in[1] >= 0x90 && debug) {
  418.         /*
  419.          * Only makes sense with buggy Ricoh firmware.
  420.          */
  421.         errmsgno(EX_BAD, "Converting ATIP from BCD\n");
  422.         atp->desc.lead_in[1] = from_bcd(atp->desc.lead_in[1]);
  423.         atp->desc.lead_in[2] = from_bcd(atp->desc.lead_in[2]);
  424.         atp->desc.lead_in[3] = from_bcd(atp->desc.lead_in[3]);
  425.  
  426.         atp->desc.lead_out[1] = from_bcd(atp->desc.lead_out[1]);
  427.         atp->desc.lead_out[2] = from_bcd(atp->desc.lead_out[2]);
  428.         atp->desc.lead_out[3] = from_bcd(atp->desc.lead_out[3]);
  429.     }
  430.  
  431.     return (ret);
  432. }
  433.  
  434. LOCAL int
  435. /*get_pma(atp)*/
  436. get_pma(scgp)
  437.     SCSI    *scgp;
  438. /*    struct atipinfo *atp;*/
  439. {
  440.     int    len;
  441.     int    ret;
  442. char    atp[1024];
  443.  
  444.     fillbytes((caddr_t)atp, sizeof(*atp), '\0');
  445.  
  446. /*    if (read_toc(scgp, (caddr_t)atp, 0, 2, 1, FMT_PMA) < 0)*/
  447.     if (read_toc(scgp, (caddr_t)atp, 0, 2, 0, FMT_PMA) < 0)
  448.         return (-1);
  449. /*    len = a_to_u_2_byte(atp->hd.len);*/
  450.     len = a_to_u_2_byte(atp);
  451.     len += 2;
  452. /*    ret = read_toc(scgp, (caddr_t)atp, 0, len, 1, FMT_PMA);*/
  453.     ret = read_toc(scgp, (caddr_t)atp, 0, len, 0, FMT_PMA);
  454.  
  455. #ifdef    DEBUG
  456.     scg_prbytes("PMA:", (u_char *)atp,
  457.                 len-scg_getresid(scgp));
  458. #endif
  459.     ret = read_toc(scgp, (caddr_t)atp, 0, len, 1, FMT_PMA);
  460.  
  461. #ifdef    DEBUG
  462.     scg_prbytes("PMA:", (u_char *)atp,
  463.                 len-scg_getresid(scgp));
  464. #endif
  465.     return (ret);
  466. }
  467.  
  468. #endif    /* PRINT_ATIP */
  469.  
  470. LOCAL int
  471. getdisktype_mmc(scgp, dp, dsp)
  472.     SCSI    *scgp;
  473.     cdr_t    *dp;
  474.     dstat_t    *dsp;
  475. {
  476. extern    char    *buf;
  477.     struct disk_info *dip;
  478.     u_char    mode[0x100];
  479.     char    ans[2];
  480.     msf_t    msf;
  481.     BOOL    did_atip = FALSE;
  482.     BOOL    did_dummy = FALSE;
  483.  
  484.     msf.msf_min = msf.msf_sec = msf.msf_frame = 0;
  485. #ifdef    PRINT_ATIP
  486.     /*
  487.      * It seems that there are drives that do not support to
  488.      * read ATIP (e.g. HP 7100)
  489.      * Also if a NON CD-R media is inserted, this will never work.
  490.      * For this reason, make a failure non-fatal.
  491.      */
  492.     scgp->silent++;
  493.     if (get_atip(scgp, (struct atipinfo *)mode) >= 0) {
  494.         msf.msf_min =        mode[8];
  495.         msf.msf_sec =        mode[9];
  496.         msf.msf_frame =        mode[10];
  497.         did_atip = TRUE;
  498.         if (lverbose) {
  499.             print_atip(scgp, (struct atipinfo *)mode);
  500.             pr_manufacturer(&msf,
  501.                 ((struct atipinfo *)mode)->desc.erasable,
  502.                 ((struct atipinfo *)mode)->desc.uru);
  503.         }
  504.     }
  505.     scgp->silent--;
  506. #endif
  507. again:
  508.     dip = (struct disk_info *)buf;
  509.     if (get_diskinfo(scgp, dip) < 0)
  510.         return (-1);
  511.  
  512.     /*
  513.      * Check for non writable disk first.
  514.      */
  515.     if (dip->disk_status == DS_COMPLETE && dsp->ds_cdrflags & RF_WRITE) {
  516.         if (!did_dummy) {
  517.             int    xspeed = 0xFFFF;
  518.  
  519.             /*
  520.              * Try to clear the dummy bit to reset the virtual
  521.              * drive status. Not all drives support it even though
  522.              * it is mentioned in the MMC standard.
  523.              */
  524.             if (lverbose)
  525.                 printf("Trying to clear drive status.\n");
  526.             speed_select_mmc(scgp, &xspeed, FALSE);
  527.             did_dummy = TRUE;
  528.             goto again;
  529.         }
  530.         errmsgno(EX_BAD, "Drive needs to reload the media to return to proper status.\n");
  531.         unload_media(scgp, dp, F_EJECT);
  532.  
  533.         if ((dp->cdr_flags & CDR_TRAYLOAD) != 0) {
  534.             scgp->silent++;
  535.             load_media(scgp, dp, FALSE);
  536.             scgp->silent--;
  537.         }
  538.         scgp->silent++;
  539.         if (((dp->cdr_flags & CDR_TRAYLOAD) == 0) ||
  540.                 !wait_unit_ready(scgp, 5)) {
  541.             scgp->silent--;
  542.  
  543.             printf("Re-load disk and hit <CR>");
  544.             if (isgui)
  545.                 printf("\n");
  546.             flush();
  547.             getline(ans, 1);
  548.         } else {
  549.             scgp->silent--;
  550.         }
  551.         load_media(scgp, dp, TRUE);
  552.     }
  553.     if (get_diskinfo(scgp, dip) < 0)
  554.         return (-1);
  555.     di_to_dstat(dip, dsp);
  556.     if (!did_atip && dsp->ds_first_leadin < 0)
  557.         lba_to_msf(dsp->ds_first_leadin, &msf);
  558.  
  559.     if (lverbose && !did_atip) {
  560.         print_min_atip(dsp->ds_first_leadin, dsp->ds_last_leadout);
  561.         if (dsp->ds_first_leadin < 0)
  562.                     pr_manufacturer(&msf,
  563.                 dip->erasable,
  564.                 dip->uru);
  565.     }
  566.     dsp->ds_maxrblocks = disk_rcap(&msf, dsp->ds_maxblocks,
  567.                 dip->erasable,
  568.                 dip->uru);
  569.  
  570.  
  571. #ifdef    PRINT_ATIP
  572. #ifdef    DEBUG
  573.     if (get_atip(scgp, (struct atipinfo *)mode) < 0)
  574.         return (-1);
  575.     /*
  576.      * Get pma gibt â”€rger mit CW-7502
  577.      * Wenn Die Disk leer ist, dann stuerzt alles ab.
  578.      * Firmware 4.02 kann nicht get_pma
  579.      */
  580.     if (dip->disk_status != DS_EMPTY) {
  581. /*        get_pma();*/
  582.     }
  583.     printf("ATIP lead in:  %ld (%02d:%02d/%02d)\n",
  584.         msf_to_lba(mode[8], mode[9], mode[10], FALSE),
  585.         mode[8], mode[9], mode[10]);
  586.     printf("ATIP lead out: %ld (%02d:%02d/%02d)\n",
  587.         msf_to_lba(mode[12], mode[13], mode[14], TRUE),
  588.         mode[12], mode[13], mode[14]);
  589.     print_di(dip);
  590.     print_atip(scgp, (struct atipinfo *)mode);
  591. #endif
  592. #endif    /* PRINT_ATIP */
  593.     return (drive_getdisktype(scgp, dp, dsp));
  594. }
  595.  
  596. #ifdef    PRINT_ATIP
  597.  
  598. #define    DOES(what,flag)    printf("  Does %s%s\n", flag?"":"not ",what);
  599. #define    IS(what,flag)    printf("  Is %s%s\n", flag?"":"not ",what);
  600. #define    VAL(what,val)    printf("  %s: %d\n", what, val[0]*256 + val[1]);
  601. #define    SVAL(what,val)    printf("  %s: %s\n", what, val);
  602.  
  603. void
  604. print_di(dip)
  605.     struct disk_info    *dip;
  606. {
  607. static    char *ds_name[] = { "empty", "incomplete/appendable", "complete", "illegal" };
  608. static    char *ss_name[] = { "empty", "incomplete/appendable", "illegal", "complete", };
  609.  
  610.     IS("erasable", dip->erasable);
  611.     printf("disk status: %s\n", ds_name[dip->disk_status]);
  612.     printf("session status: %s\n", ss_name[dip->sess_status]);
  613.     printf("first track: %d number of sessions: %d first track in last sess: %d last track in last sess: %d\n",
  614.         dip->first_track,
  615.         dip->numsess,
  616.         dip->first_track_ls,
  617.         dip->last_track_ls);
  618.     IS("unrestricted", dip->uru);
  619.     printf("Disk type: ");
  620.     switch (dip->disk_type) {
  621.  
  622.     case SES_DA_ROM:    printf("CD-DA or CD-ROM");    break;
  623.     case SES_CDI:        printf("CDI");            break;
  624.     case SES_XA:        printf("CD-ROM XA");        break;
  625.     case SES_UNDEF:        printf("undefined");        break;
  626.     default:        printf("reserved");        break;
  627.     }
  628.     printf("\n");
  629.     if (dip->did_v)
  630.         printf("Disk id: 0x%lX\n", a_to_u_4_byte(dip->disk_id));
  631.  
  632.     printf("last start of lead in: %ld\n",
  633.         msf_to_lba(dip->last_lead_in[1],
  634.         dip->last_lead_in[2],
  635.         dip->last_lead_in[3], FALSE));
  636.     printf("last start of lead out: %ld\n",
  637.         msf_to_lba(dip->last_lead_out[1],
  638.         dip->last_lead_out[2],
  639.         dip->last_lead_out[3], TRUE));
  640.  
  641.     if (dip->dbc_v)
  642.         printf("Disk bar code: 0x%lX%lX\n",
  643.             a_to_u_4_byte(dip->disk_barcode),
  644.             a_to_u_4_byte(&dip->disk_barcode[4]));
  645.  
  646.     if (dip->num_opc_entries > 0) {
  647.         printf("OPC table:\n");
  648.     }
  649. }
  650.  
  651. LOCAL    char    clv_to_speed[8] = {
  652.         0, 2, 4, 6, 8, 0, 0, 0
  653. };
  654.  
  655. char    *cdr_subtypes[] = {
  656.     "Normal Rewritable (CLV) media",
  657.     "High speed Rewritable (CAV) media",
  658.     "Medium Type A, low Beta category (A-)",
  659.     "Medium Type A, high Beta category (A+)",
  660.     "Medium Type B, low Beta category (B-)",
  661.     "Medium Type B, high Beta category (B+)",
  662.     "Medium Type C, low Beta category (C-)",
  663.     "Medium Type C, high Beta category (C+)",
  664. };
  665.  
  666. void
  667. print_atip(scgp, atp)
  668.     SCSI        *scgp;
  669.     struct atipinfo *atp;
  670. {
  671.     char    *sub_type;
  672.  
  673.     if (scgp->verbose)
  674.         scg_prbytes("ATIP info: ", (Uchar *)atp, sizeof (*atp));
  675.  
  676.     printf("ATIP info from disk:\n");
  677.     printf("  Indicated writing power: %d\n", atp->desc.ind_wr_power);
  678.     if (atp->desc.erasable || atp->desc.ref_speed)
  679.         printf("  Reference speed: %d\n", clv_to_speed[atp->desc.ref_speed]);
  680.     IS("unrestricted", atp->desc.uru);
  681. /*    printf("  Disk application code: %d\n", atp->desc.res5_05);*/
  682.     IS("erasable", atp->desc.erasable);
  683.     sub_type = cdr_subtypes[atp->desc.sub_type];
  684.     if (atp->desc.sub_type)
  685.         printf("  Disk sub type: %s (%d)\n", sub_type, atp->desc.sub_type);
  686.     printf("  ATIP start of lead in:  %ld (%02d:%02d/%02d)\n",
  687.         msf_to_lba(atp->desc.lead_in[1],
  688.         atp->desc.lead_in[2],
  689.         atp->desc.lead_in[3], FALSE),
  690.         atp->desc.lead_in[1],
  691.         atp->desc.lead_in[2],
  692.         atp->desc.lead_in[3]);
  693.     printf("  ATIP start of lead out: %ld (%02d:%02d/%02d)\n",
  694.         msf_to_lba(atp->desc.lead_out[1],
  695.         atp->desc.lead_out[2],
  696.         atp->desc.lead_out[3], TRUE),
  697.         atp->desc.lead_out[1],
  698.         atp->desc.lead_out[2],
  699.         atp->desc.lead_out[3]);
  700.     if (atp->desc.a1_v) {
  701.         if (atp->desc.clv_low != 0 || atp->desc.clv_high != 0)
  702.             printf("  speed low: %d speed high: %d\n",
  703.                 clv_to_speed[atp->desc.clv_low],
  704.                 clv_to_speed[atp->desc.clv_high]);
  705.         printf("  power mult factor: %d %d\n", atp->desc.power_mult, atp->desc.tgt_y_pow);
  706.         if (atp->desc.erasable)
  707.             printf("  recommended erase/write power: %d\n", atp->desc.rerase_pwr_ratio);
  708.     }
  709.     if (atp->desc.a2_v) {
  710.         printf("  A2 values: %02X %02X %02X\n",
  711.                 atp->desc.a2[0],
  712.                 atp->desc.a2[1],
  713.                 atp->desc.a2[2]);
  714.     }
  715.     if (atp->desc.a3_v) {
  716.         printf("  A3 values: %02X %02X %02X\n",
  717.                 atp->desc.a3[0],
  718.                 atp->desc.a3[1],
  719.                 atp->desc.a3[2]);
  720.     }
  721. }
  722. #endif    /* PRINT_ATIP */
  723.  
  724. LOCAL int
  725. speed_select_mmc(scgp, speedp, dummy)
  726.     SCSI    *scgp;
  727.     int    *speedp;
  728.     int    dummy;
  729. {
  730.     u_char    mode[0x100];
  731.     int    len;
  732.     struct    cd_mode_page_05 *mp;
  733.     int    val;
  734.  
  735.     if (speedp)
  736.         curspeed = *speedp;
  737.  
  738.     fillbytes((caddr_t)mode, sizeof(mode), '\0');
  739.  
  740.     if (!get_mode_params(scgp, 0x05, "CD write parameter",
  741.             mode, (u_char *)0, (u_char *)0, (u_char *)0, &len))
  742.         return (-1);
  743.     if (len == 0)
  744.         return (-1);
  745.  
  746.     mp = (struct cd_mode_page_05 *)
  747.         (mode + sizeof(struct scsi_mode_header) +
  748.         ((struct scsi_mode_header *)mode)->blockdesc_len);
  749. #ifdef    DEBUG
  750.     scg_prbytes("CD write parameter:", (u_char *)mode, len);
  751. #endif
  752.  
  753.  
  754.     mp->test_write = dummy != 0;
  755.     /*
  756.      * Set default values:
  757.      * Write type = 01 (track at once)
  758.      * Track mode = 04 (CD-ROM)
  759.      * Data block type = 08 (CD-ROM)
  760.      * Session format = 00 (CD-ROM)
  761.      */
  762.     mp->write_type = WT_TAO;
  763.     mp->track_mode = TM_DATA; 
  764.     mp->dbtype = DB_ROM_MODE1;
  765.     mp->session_format = SES_DA_ROM;/* Matsushita has illegal def. value */
  766.  
  767.  
  768. #ifdef    DEBUG
  769.     scg_prbytes("CD write parameter:", (u_char *)mode, len);
  770. #endif
  771.     if (!set_mode_params(scgp, "CD write parameter", mode, len, 0, -1))
  772.         return (-1);
  773.  
  774.     if (speedp == 0)
  775.         return (0);
  776.  
  777. /*    if (scsi_set_speed(-1, curspeed*176) < 0)*/
  778.  
  779.     /*
  780.      * 44100 * 2 * 2 =  176400 bytes/s
  781.      *
  782.      * The right formula would be:
  783.      * tmp = (((long)curspeed) * 1764) / 10;
  784.      *
  785.      * But the standard is rounding the wrong way.
  786.      * Furtunately rounding down is guaranteed.
  787.      */
  788.     if (scsi_set_speed(scgp, -1, curspeed*177) < 0)
  789.         return (-1);
  790.  
  791.     if (scsi_get_speed(scgp, 0, &val) >= 0) {
  792.         curspeed = val / 176;
  793.         *speedp = curspeed;
  794.     }
  795.     return (0);
  796. }
  797.  
  798. LOCAL int
  799. next_wr_addr_mmc(scgp, track, trackp, ap)
  800.     SCSI    *scgp;
  801.     int    track;
  802.     track_t    *trackp;
  803.     long    *ap;
  804. {
  805.     struct    track_info    track_info;
  806.     long    next_addr;
  807.     int    result = -1;
  808.  
  809.  
  810.     /*
  811.      * Reading info for current track may require doing the read_track_info
  812.      * with either the track number (if the track is currently being written)
  813.      * or with 0xFF (if the track hasn't been started yet and is invisible
  814.      */
  815.  
  816.     if (track > 0 && is_packet(trackp)) {
  817.         scgp->silent++;
  818.         result = read_track_info(scgp, (caddr_t)&track_info, track,
  819.                             sizeof(track_info));
  820.         scgp->silent--;
  821.     }
  822.  
  823.     if (result < 0) {
  824.         if (read_track_info(scgp, (caddr_t)&track_info, 0xFF,
  825.                         sizeof(track_info)) < 0)
  826.         return (-1);
  827.     }
  828.     if (scgp->verbose)
  829.         scg_prbytes("track info:", (u_char *)&track_info,
  830.                 sizeof(track_info)-scg_getresid(scgp));
  831.     next_addr = a_to_4_byte(track_info.next_writable_addr);
  832.     if (ap)
  833.         *ap = next_addr;
  834.     return (0);
  835. }
  836.  
  837. int    st2mode[] = {
  838.     0,        /* 0            */
  839.     TM_DATA,    /* 1 ST_ROM_MODE1    */
  840.     TM_DATA,    /* 2 ST_ROM_MODE2    */
  841.     0,        /* 3            */
  842.     0,        /* 4 ST_AUDIO_NOPRE    */
  843.     TM_PREEM,    /* 5 ST_AUDIO_PRE    */
  844.     0,        /* 6            */
  845.     0,        /* 7            */
  846. };
  847.  
  848. LOCAL int
  849. open_track_mmc(scgp, dp, track, trackp)
  850.     SCSI    *scgp;
  851.     cdr_t    *dp;
  852.     int    track;
  853.     track_t *trackp;
  854. {
  855.     u_char    mode[0x100];
  856.     int    len;
  857.     struct    cd_mode_page_05 *mp;
  858.  
  859.     if (!is_tao(trackp)) {
  860.         if (trackp->pregapsize > 0 && (trackp->flags & TI_PREGAP) == 0) {
  861.             if (lverbose) {
  862.                 printf("Writing pregap for track %d at %ld\n",
  863.                     track,
  864.                     trackp->trackstart-trackp->pregapsize);
  865.             }
  866.             pad_track(scgp, dp, track, trackp,
  867.                 trackp->trackstart-trackp->pregapsize,
  868.                 trackp->pregapsize*trackp->secsize,
  869.                     FALSE, 0);
  870.         }
  871.         return (0);
  872.     }
  873.  
  874.     fillbytes((caddr_t)mode, sizeof(mode), '\0');
  875.  
  876.     if (!get_mode_params(scgp, 0x05, "CD write parameter",
  877.             mode, (u_char *)0, (u_char *)0, (u_char *)0, &len))
  878.         return (-1);
  879.     if (len == 0)
  880.         return (-1);
  881.  
  882.     mp = (struct cd_mode_page_05 *)
  883.         (mode + sizeof(struct scsi_mode_header) +
  884.         ((struct scsi_mode_header *)mode)->blockdesc_len);
  885.  
  886.  
  887. /*    mp->track_mode = ???;*/
  888.     mp->track_mode = st2mode[trackp->sectype & ST_MASK];
  889. /*    mp->copy = ???;*/
  890.     mp->dbtype = trackp->dbtype;
  891.  
  892. /*i_to_short(mp->audio_pause_len, 300);*/
  893. /*i_to_short(mp->audio_pause_len, 150);*/
  894. /*i_to_short(mp->audio_pause_len, 0);*/
  895.  
  896.     if (is_packet(trackp)) {
  897.         mp->write_type = WT_PACKET;
  898.         mp->track_mode |= TM_INCREMENTAL;
  899.         mp->fp = (trackp->pktsize > 0) ? 1 : 0;
  900.         i_to_4_byte(mp->packet_size, trackp->pktsize);
  901.     } else {
  902.         mp->write_type = WT_TAO;
  903.         mp->fp = 0;
  904.         i_to_4_byte(mp->packet_size, 0);
  905.     }
  906.     if (trackp->isrc) {
  907.         mp->ISRC[0] = 0x80;    /* Set ISRC valid */
  908.         strncpy((char *)&mp->ISRC[1], trackp->isrc, 12);
  909.  
  910.     } else {
  911.         fillbytes(&mp->ISRC[0], sizeof(mp->ISRC), '\0');
  912.     }
  913.  
  914. #ifdef    DEBUG
  915.     scg_prbytes("CD write parameter:", (u_char *)mode, len);
  916. #endif
  917.     if (!set_mode_params(scgp, "CD write parameter", mode, len, 0, trackp->secsize))
  918.         return (-1);
  919.  
  920.     return (0);
  921. }
  922.  
  923. LOCAL int
  924. close_track_mmc(scgp, track, trackp)
  925.     SCSI    *scgp;
  926.     int    track;
  927.     track_t    *trackp;
  928. {
  929.     int    ret;
  930.  
  931.     if (!is_tao(trackp))
  932.         return (0);
  933.  
  934.     if (scsi_flush_cache(scgp) < 0) {
  935.         printf("Trouble flushing the cache\n");
  936.         return -1;
  937.     }
  938.     wait_unit_ready(scgp, 300);        /* XXX Wait for ATAPI */
  939.     if (is_packet(trackp) && !is_noclose(trackp)) {
  940.             /* close the incomplete track */
  941.         ret = scsi_close_tr_session(scgp, 1, 0xFF, FALSE);
  942.         wait_unit_ready(scgp, 300);    /* XXX Wait for ATAPI */
  943.         return (ret);
  944.     }
  945.     return (0);
  946. }
  947.  
  948. int    toc2sess[] = {
  949.     SES_DA_ROM,    /* CD-DA         */
  950.     SES_DA_ROM,    /* CD-ROM         */
  951.     SES_XA,        /* CD-ROM XA mode 1     */
  952.     SES_XA,        /* CD-ROM XA MODE 2     */
  953.     SES_CDI,    /* CDI             */
  954.     SES_DA_ROM,    /* Invalid - use default */
  955.     SES_DA_ROM,    /* Invalid - use default */
  956. };
  957.  
  958. LOCAL int
  959. open_session_mmc(scgp, dp, tracks, trackp, toctype, multi)
  960.     SCSI    *scgp;
  961.     cdr_t    *dp;
  962.     int    tracks;
  963.     track_t    *trackp;
  964.     int    toctype;
  965.     int    multi;
  966. {
  967.     u_char    mode[0x100];
  968.     int    len;
  969.     struct    cd_mode_page_05 *mp;
  970.  
  971.     fillbytes((caddr_t)mode, sizeof(mode), '\0');
  972.  
  973.     if (!get_mode_params(scgp, 0x05, "CD write parameter",
  974.             mode, (u_char *)0, (u_char *)0, (u_char *)0, &len))
  975.         return (-1);
  976.     if (len == 0)
  977.         return (-1);
  978.  
  979.     mp = (struct cd_mode_page_05 *)
  980.         (mode + sizeof(struct scsi_mode_header) +
  981.         ((struct scsi_mode_header *)mode)->blockdesc_len);
  982.  
  983.     mp->write_type = WT_TAO; /* fix to allow DAO later */
  984.     if (!is_tao(trackp)) {
  985.         mp->write_type = WT_SAO;
  986.         mp->track_mode = 0;
  987.         mp->dbtype = DB_RAW;
  988.     }
  989.  
  990.     if (driveropts != NULL) {
  991.         if (strcmp(driveropts, "burnproof") == 0 && dp->cdr_cdcap->res_4 != 0) {
  992.             errmsgno(EX_BAD, "Turning BURN-Proof on\n");
  993.             mp->res_2 |= 2;
  994.         } else if (strcmp(driveropts, "noburnproof") == 0) {
  995.             errmsgno(EX_BAD, "Turning BURN-Proof off\n");
  996.             mp->res_2 &= ~2;
  997.         } else if (strcmp(driveropts, "help") == 0) {
  998.             mmc_opthelp(dp, 0);
  999.         } else {
  1000.             errmsgno(EX_BAD, "Bad driver opts '%s'.\n", driveropts);
  1001.             mmc_opthelp(dp, EX_BAD);
  1002.         }
  1003.     }
  1004.  
  1005.     mp->multi_session = (multi != 0) ? MS_MULTI : MS_NONE;
  1006.     mp->session_format = toc2sess[toctype & TOC_MASK];
  1007.  
  1008.     if (trackp->isrc) {
  1009.         mp->media_cat_number[0] = 0x80;    /* Set MCN valid */
  1010.         strncpy((char *)&mp->media_cat_number[1], trackp->isrc, 13);
  1011.  
  1012.     } else {
  1013.         fillbytes(&mp->media_cat_number[0], sizeof(mp->media_cat_number), '\0');
  1014.     }
  1015. #ifdef    DEBUG
  1016.     scg_prbytes("CD write parameter:", (u_char *)mode, len);
  1017. #endif
  1018.     if (!set_mode_params(scgp, "CD write parameter", mode, len, 0, -1))
  1019.         return (-1);
  1020.  
  1021.     return (0);
  1022. }
  1023.  
  1024. LOCAL int
  1025. waitfix_mmc(scgp, secs)
  1026.     SCSI    *scgp;
  1027.     int    secs;
  1028. {
  1029.     char    dibuf[16];
  1030.     int    i;
  1031.     int    key;
  1032. #define    W_SLEEP    2
  1033.  
  1034.     scgp->silent++;
  1035.     for (i = 0; i < secs/W_SLEEP; i++) {
  1036.         if (read_disk_info(scgp, dibuf, sizeof(dibuf)) >= 0) {
  1037.             scgp->silent--;
  1038.             return (0);
  1039.         }
  1040.         key = scg_sense_key(scgp);
  1041.         if (key != SC_UNIT_ATTENTION && key != SC_NOT_READY)
  1042.             break;
  1043.         sleep(W_SLEEP);
  1044.     }
  1045.     scgp->silent--;
  1046.     return (-1);
  1047. #undef    W_SLEEP
  1048. }
  1049.  
  1050. LOCAL int
  1051. fixate_mmc(scgp, onp, dummy, toctype, tracks, trackp)
  1052.     SCSI    *scgp;
  1053.     int    onp;
  1054.     int    dummy;
  1055.     int    toctype;
  1056.     int    tracks;
  1057.     track_t    *trackp;
  1058. {
  1059.     int    ret = 0;
  1060.     int    key = 0;
  1061.     int    code = 0;
  1062.     struct timeval starttime;
  1063.     struct timeval stoptime;
  1064.  
  1065.     starttime.tv_sec = 0;
  1066.     starttime.tv_usec = 0;
  1067.     stoptime = starttime;
  1068.     gettimeofday(&starttime, (struct timezone *)0);
  1069.  
  1070.     if (dummy && lverbose)
  1071.         printf("WARNING: Some drives don't like fixation in dummy mode.\n");
  1072.  
  1073.     scgp->silent++;
  1074.     if (is_tao(trackp)) {
  1075.         ret = scsi_close_tr_session(scgp, 2, 0, FALSE);
  1076.     } else {
  1077.         if (scsi_flush_cache(scgp) < 0) {
  1078.             if (!scsi_in_progress(scgp))
  1079.                 printf("Trouble flushing the cache\n");
  1080.         }
  1081.     }
  1082.     scgp->silent--;
  1083.     key = scg_sense_key(scgp);
  1084.     code = scg_sense_code(scgp);
  1085.  
  1086.     scgp->silent++;
  1087.     if (debug && !unit_ready(scgp)) {
  1088.         error("Early return from fixating. Ret: %d Key: %d, Code: %d\n", ret, key, code);
  1089.     }
  1090.     scgp->silent--;
  1091.  
  1092.     if (ret >= 0) {
  1093.         wait_unit_ready(scgp, 420/curspeed);    /* XXX Wait for ATAPI */
  1094.         waitfix_mmc(scgp, 420/curspeed);    /* XXX Wait for ATAPI */
  1095.         return (ret);
  1096.     }
  1097.  
  1098.     if ((dummy != 0 && (key != SC_ILLEGAL_REQUEST)) ||
  1099.         /*
  1100.          * Try to suppress messages from drives that don't like fixation
  1101.          * in -dummy mode.
  1102.          */
  1103.         ((dummy == 0) &&
  1104.          ( ((key != SC_UNIT_ATTENTION) && (key != SC_NOT_READY)) ||
  1105.                 ((code != 0x2E) && (code != 0x04)) ))) {
  1106.         /*
  1107.          * UNIT ATTENTION/2E seems to be a magic for old Mitsumi ATAPI drives
  1108.          * NOT READY/ code 4 qual 7 (logical unit not ready, operation in progress)
  1109.          * seems to be a magic for newer Mitsumi ATAPI drives
  1110.          * NOT READY/ code 4 qual 8 (logical unit not ready, long write in progress)
  1111.          * seems to be a magic for SONY drives
  1112.          * when returning early from fixating.
  1113.          * Try to supress the error message in this case to make
  1114.          * simple minded users less confused.
  1115.          */
  1116.         scg_printerr(scgp);
  1117.         scg_printresult(scgp);    /* XXX restore key/code in future */
  1118.     }
  1119.  
  1120.     if (debug && !unit_ready(scgp)) {
  1121.         error("Early return from fixating. Ret: %d Key: %d, Code: %d\n", ret, key, code);
  1122.     }
  1123.     scgp->silent--;
  1124.  
  1125.     wait_unit_ready(scgp, 420);    /* XXX Wait for ATAPI */
  1126.     waitfix_mmc(scgp, 420/curspeed);/* XXX Wait for ATAPI */
  1127.  
  1128.     if (!dummy &&
  1129.         (ret >= 0 || (key == SC_UNIT_ATTENTION && code == 0x2E))) {
  1130.         /*
  1131.          * Some ATAPI drives (e.g. Mitsumi) imply the
  1132.          * IMMED bit in the SCSI cdb. As there seems to be no
  1133.          * way to properly check for the real end of the
  1134.          * fixating process we wait for the expected time.
  1135.          */
  1136.         gettimeofday(&stoptime, (struct timezone *)0);
  1137.         timevaldiff(&starttime, &stoptime);
  1138.         if (stoptime.tv_sec < (220 / curspeed)) {
  1139.             unsigned secs;
  1140.  
  1141.             if (lverbose) {
  1142.                 printf("Actual fixating time: %ld seconds\n",
  1143.                             (long)stoptime.tv_sec);
  1144.             }
  1145.             secs = (280 / curspeed) - stoptime.tv_sec;
  1146.             if (lverbose) {
  1147.                 printf("ATAPI early return: sleeping %d seconds.\n",
  1148.                                 secs);
  1149.             }
  1150.             sleep(secs);
  1151.         }
  1152.     }
  1153.     return (ret);
  1154. }
  1155.  
  1156. char    *blank_types[] = {
  1157.     "entire disk",
  1158.     "PMA, TOC, pregap",
  1159.     "incomplete track",
  1160.     "reserved track",
  1161.     "tail of track",
  1162.     "closing of last session",
  1163.     "last session",
  1164.     "reserved blanking type",
  1165. };
  1166.  
  1167. LOCAL int
  1168. blank_mmc(scgp, addr, blanktype)
  1169.     SCSI    *scgp;
  1170.     long    addr;
  1171.     int    blanktype;
  1172. {
  1173.     BOOL    cdrr     = FALSE;    /* Read CD-R    */
  1174.     BOOL    cdwr     = FALSE;    /* Write CD-R    */
  1175.     BOOL    cdrrw     = FALSE;    /* Read CD-RW    */
  1176.     BOOL    cdwrw     = FALSE;    /* Write CD-RW    */
  1177.  
  1178.     mmc_check(scgp, &cdrr, &cdwr, &cdrrw, &cdwrw, NULL);
  1179.     if (!cdwrw)
  1180.         return (blank_dummy(scgp, addr, blanktype));
  1181.  
  1182.     if (lverbose) {
  1183.         printf("Blanking %s\n", blank_types[blanktype & 0x07]);
  1184.         flush();
  1185.     }
  1186.  
  1187.     return (scsi_blank(scgp, addr, blanktype, FALSE));
  1188. }
  1189.  
  1190. LOCAL int
  1191. send_opc_mmc(scgp, bp, cnt, doopc)
  1192.     SCSI    *scgp;
  1193.     caddr_t    bp;
  1194.     int    cnt;
  1195.     int    doopc;
  1196. {
  1197.     int    ret;
  1198.  
  1199.     scgp->silent++;
  1200.     ret = send_opc(scgp, bp, cnt, doopc);
  1201.     scgp->silent--;
  1202.  
  1203.     if (ret >= 0)
  1204.         return (ret);
  1205.  
  1206.     /*
  1207.      * Send OPC is optional.
  1208.      */
  1209.     if (scg_sense_key(scgp) != SC_ILLEGAL_REQUEST) {
  1210.         if (scgp->silent <= 0)
  1211.             scg_printerr(scgp);
  1212.         return (ret);
  1213.     }
  1214.     return (0);
  1215. }
  1216.  
  1217. LOCAL int
  1218. scsi_sony_write(scgp, bp, sectaddr, size, blocks, islast)
  1219.     SCSI    *scgp;
  1220.     caddr_t    bp;        /* address of buffer */
  1221.     long    sectaddr;    /* disk address (sector) to put */
  1222.     long    size;        /* number of bytes to transfer */
  1223.     int    blocks;        /* sector count */
  1224.     BOOL    islast;        /* last write for track */
  1225. {
  1226.     return (write_xg5(scgp, bp, sectaddr, size, blocks));
  1227. }
  1228.  
  1229. Uchar    db2df[] = {
  1230.     0x00,            /*  0 2352 bytes of raw data            */
  1231.     0xFF,            /*  1 2368 bytes (raw data + P/Q Subchannel)    */
  1232.     0xFF,            /*  2 2448 bytes (raw data + P-W Subchannel)    */
  1233.     0xFF,            /*  3 2448 bytes (raw data + P-W raw Subchannel)*/
  1234.     0xFF,            /*  4 -    Reserved                */
  1235.     0xFF,            /*  5 -    Reserved                */
  1236.     0xFF,            /*  6 -    Reserved                */
  1237.     0xFF,            /*  7 -    Vendor specific            */
  1238.     0x10,            /*  8 2048 bytes Mode 1 (ISO/IEC 10149)        */
  1239.     0xFF,            /*  9 2336 bytes Mode 2 (ISO/IEC 10149)        */
  1240.     0xFF,            /* 10 2048 bytes Mode 2! (CD-ROM XA form 1)    */
  1241.     0xFF,            /* 11 2056 bytes Mode 2 (CD-ROM XA form 1)    */
  1242.     0xFF,            /* 12 2324 bytes Mode 2 (CD-ROM XA form 2)    */
  1243.     0xFF,            /* 13 2332 bytes Mode 2 (CD-ROM XA 1/2+subhdr)    */
  1244.     0xFF,            /* 14 -    Reserved                */
  1245.     0xFF,            /* 15 -    Vendor specific            */
  1246. };
  1247.  
  1248. LOCAL    void    fillcue        __PR((struct mmc_cue *cp, int ca, int tno, int idx, int dataform, int scms, msf_t *mp));
  1249. EXPORT    int    do_cue        __PR((int tracks, track_t *trackp, struct mmc_cue **cuep));
  1250. EXPORT    int    _do_cue        __PR((int tracks, track_t *trackp, struct mmc_cue **cuep, BOOL needgap));
  1251. LOCAL    int    send_cue    __PR((SCSI *scgp, int tracks, track_t *trackp));
  1252.  
  1253. EXPORT int
  1254. do_cue(tracks, trackp, cuep)
  1255.     int    tracks;
  1256.     track_t    *trackp;
  1257.     struct mmc_cue    **cuep;
  1258. {
  1259.     return (_do_cue(tracks, trackp, cuep, FALSE));
  1260. }
  1261.  
  1262. EXPORT int
  1263. _do_cue(tracks, trackp, cuep, needgap)
  1264.     int    tracks;
  1265.     track_t    *trackp;
  1266.     struct mmc_cue    **cuep;
  1267.     BOOL    needgap;
  1268. {
  1269.     int    i;
  1270.     struct mmc_cue    *cue;
  1271.     struct mmc_cue    *cp;
  1272.     int    ncue = 0;
  1273.     int    icue = 0;
  1274.     int    pgsize;
  1275.     msf_t    m;
  1276.     int    ctl;
  1277.     int    df;
  1278.     int    scms;
  1279.  
  1280.     cue = (struct mmc_cue *)malloc(1);
  1281.  
  1282.     for (i = 0; i <= tracks; i++) {
  1283.         ctl = (st2mode[trackp[i].sectype & ST_MASK]) << 4;
  1284.         if (is_copy(&trackp[i]))
  1285.             ctl |= TM_ALLOW_COPY << 4;
  1286.         df = db2df[trackp[i].dbtype & 0x0F];
  1287.  
  1288.         if (trackp[i].isrc) {    /* MCN or ISRC */
  1289.             ncue += 2;
  1290.             cue = (struct mmc_cue *)realloc(cue, ncue * sizeof(*cue));
  1291.             cp = &cue[icue++];
  1292.             if (i == 0) {
  1293.                 cp->cs_ctladr = 0x02;
  1294.                 movebytes(&trackp[i].isrc[0], &cp->cs_tno, 7);
  1295.                 cp = &cue[icue++];
  1296.                 cp->cs_ctladr = 0x02;
  1297.                 movebytes(&trackp[i].isrc[7], &cp->cs_tno, 7);
  1298.             } else {
  1299.                 cp->cs_ctladr = 0x03;
  1300.                 cp->cs_tno = i;
  1301.                 movebytes(&trackp[i].isrc[0], &cp->cs_index, 6);
  1302.                 cp = &cue[icue++];
  1303.                 cp->cs_ctladr = 0x03;
  1304.                 cp->cs_tno = i;
  1305.                 movebytes(&trackp[i].isrc[6], &cp->cs_index, 6);
  1306.             }
  1307.         }
  1308.         if (i == 0) {    /* Lead in */
  1309.             if (df < 0x10)
  1310.                 df |= 1;
  1311.             else
  1312.                 df |= 4;
  1313.             lba_to_msf(-150, &m);
  1314.             cue = (struct mmc_cue *)realloc(cue, ++ncue * sizeof(*cue));
  1315.             cp = &cue[icue++];
  1316.             fillcue(cp, ctl|0x01, i, 0, df, 0, &m);
  1317.         } else {
  1318.             scms = 0;
  1319.  
  1320.             if (is_scms(&trackp[i]))
  1321.                 scms = 0x80;
  1322.             pgsize = trackp[i].pregapsize;
  1323.             if (pgsize == 0 && needgap)
  1324.                 pgsize++;
  1325.             lba_to_msf(trackp[i].trackstart-pgsize, &m);
  1326.             cue = (struct mmc_cue *)realloc(cue, ++ncue * sizeof(*cue));
  1327.             cp = &cue[icue++];
  1328.             fillcue(cp, ctl|0x01, i, 0, df, scms, &m);
  1329.  
  1330.             if (trackp[i].nindex == 1) {
  1331.                 lba_to_msf(trackp[i].trackstart, &m);
  1332.                 cue = (struct mmc_cue *)realloc(cue, ++ncue * sizeof(*cue));
  1333.                 cp = &cue[icue++];
  1334.                 fillcue(cp, ctl|0x01, i, 1, df, scms, &m);
  1335.             } else {
  1336.                 int    idx;
  1337.                 long    *idxlist;
  1338.  
  1339.                 ncue += trackp[i].nindex;
  1340.                 idxlist = trackp[i].tindex;
  1341.                 cue = (struct mmc_cue *)realloc(cue, ncue * sizeof(*cue));
  1342.  
  1343.                 for(idx = 1; idx <=trackp[i].nindex; idx++) {
  1344.                     lba_to_msf(trackp[i].trackstart + idxlist[idx], &m);
  1345.                     cp = &cue[icue++];
  1346.                     fillcue(cp, ctl|0x01, i, idx, df, scms, &m);
  1347.                 }
  1348.             }
  1349.         }
  1350.     }
  1351.     /* Lead out */
  1352.     ctl = (st2mode[trackp[tracks+1].sectype & ST_MASK]) << 4;
  1353.     df = db2df[trackp[tracks+1].dbtype & 0x0F];
  1354.     if (df < 0x10)
  1355.         df |= 1;
  1356.     else
  1357.         df |= 4;
  1358.     lba_to_msf(trackp[tracks+1].trackstart, &m);
  1359.     cue = (struct mmc_cue *)realloc(cue, ++ncue * sizeof(*cue));
  1360.     cp = &cue[icue++];
  1361.     fillcue(cp, ctl|0x01, 0xAA, 1, df, 0, &m);
  1362.  
  1363.     if (lverbose > 1) for (i = 0; i < ncue; i++) {
  1364.         scg_prbytes("", (Uchar *)&cue[i], 8);
  1365.     }
  1366.     if (cuep)
  1367.         *cuep = cue;
  1368.     else
  1369.         free (cue);
  1370.     return (ncue);
  1371. }
  1372.  
  1373. LOCAL void
  1374. fillcue(cp, ca, tno, idx, dataform, scms, mp)
  1375.     struct mmc_cue    *cp;    /* The target cue entry        */
  1376.     int    ca;        /* Control/adr for this entry    */
  1377.     int    tno;        /* Track number for this entry    */
  1378.     int    idx;        /* Index for this entry        */
  1379.     int    dataform;    /* Data format for this entry    */
  1380.     int    scms;        /* Serial copy management    */
  1381.     msf_t    *mp;        /* MSF value for this entry    */
  1382. {
  1383.     cp->cs_ctladr = ca;    /* XXX wie lead in */
  1384.     cp->cs_tno = tno;
  1385.     cp->cs_index = idx;
  1386.     cp->cs_dataform = dataform;/* XXX wie lead in */
  1387.     cp->cs_scms = scms;
  1388.     cp->cs_min = mp->msf_min;
  1389.     cp->cs_sec = mp->msf_sec;
  1390.     cp->cs_frame = mp->msf_frame;
  1391. }
  1392.  
  1393. LOCAL int
  1394. send_cue(scgp, tracks, trackp)
  1395.     SCSI    *scgp;
  1396.     int    tracks;
  1397.     track_t    *trackp;
  1398. {
  1399.     struct mmc_cue    *cp;
  1400.     int        ncue;
  1401.     int        ret;
  1402.     int        i;
  1403.  
  1404.     ncue = do_cue(tracks, trackp, &cp);
  1405.     for (i = 1; i <= tracks; i++) {
  1406.         if (trackp[i].tracksize < 0) {
  1407.             errmsgno(EX_BAD, "Track %d has unknown length.\n", i);
  1408.             return (-1);
  1409.         }
  1410.     }
  1411.     scgp->silent++;
  1412.     ret = send_cue_sheet(scgp, (caddr_t)cp, ncue*8);
  1413.     scgp->silent--;
  1414.     free(cp);
  1415.     if (ret < 0) {
  1416.         errmsgno(EX_BAD, "CUE sheet not accepted. Retrying with minimum pregapsize = 1.\n");
  1417.         ncue = _do_cue(tracks, trackp, &cp, TRUE);
  1418.         ret = send_cue_sheet(scgp, (caddr_t)cp, ncue*8);
  1419.         free(cp);
  1420.     }
  1421.     return (ret);
  1422. }
  1423.